



    class Animal {//对共性的抽取 进行复用
        public String name;
        public int age;

        static {
            System.out.println("Animal::静态方法");
        }

        {
            System.out.println("Animal::实例化");
        }

        public Animal(String name, int age) {//当父类中出现构造方法时 子类必须先对其进行初始化
            this.name = name;
            this.age = age;
            System.out.println("Animal(String name, int age)");
        }

        public void eat() {
            System.out.println(this.name + "正在吃....");
        }
    }
    class Dog extends Animal {
       public String color;
        static {
            System.out.println("Dog::静态方法");
        }

        {
            System.out.println("Dog::实例化");
        }
       public Dog(String name,int age,String color) {
           super(name,age);   //首先使用super调用父类构造方法完成初始化
           this.color = color;//然后再对自己变量初始化
           System.out.println("Dog(String name,int age,String color)");
       }
        public void bark() {
            System.out.println(this.name + "正在汪汪叫....");
         }
    }

    class Cat extends Animal {

    public Cat(String name,int age) {
        super(name, age);
    }
        public void bark() {
            System.out.println(this.name + "正在喵喵叫....");
        }
    }

    class Base {
        public int a = 1;
        public int b = 2;
        public void method1() {
            System.out.println("Base::method1");
        }
    }
    class Derived extends Base {
        public int a = 10;
        public int c = 20;
        public void method() {
            //成员变量的调用
//            System.out.println(a);//都具有相同变量时，优先调用本类内变量
//            System.out.println(b);//在本类不存在时去父类内寻找
//            System.out.println(c);//this 调用类内变量 优先局部变量
//            System.out.println(super.a);//想要调动父类中变量时使用super(调用父类变量、方法、构造方法)
            System.out.println("Derived::method");
            //类名不同时 分别调用
        }
        public void method1() {
            super.method1();//同名需要使用父类变量方法时 受用super.调用
            System.out.println("Derived::method1！");//类名相同时 优先调用局部类
        }
    }
    public class Test {
//    public static void main1(String[] args) {
//        //继承：专门用来进行共性抽取，实现代码复用。
//        //语法：修饰符 class 子类 extends 父类 {}
//        //Animal：父类、基类、超生类
//        //dog cat: 子类、派生类
//        //1. 子类会将父类中的成员变量或者成员方法继承到子类中了
//        //2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了
//        Dog dog = new Dog();
//        dog.name = "旺财" ;
//        dog.age = 2;
//        dog.color  = "黄色";
//        dog.eat();
//        dog.bark();
//
//        Cat cat = new Cat();
//        cat.name = "喵喵";
//        cat.age = 2;
//        cat.eat();
//        cat.bark();
//    }

        public static void main2(String[] args) {
            //父类成员访问
            //如果访问的成员变量子类中有，优先访问自己的成员变量。
            //如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
            //如果访问的成员变量与父类中成员变量同名，则优先访问自己的。
            //成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找
            Derived derived = new Derived();
            derived.method1();
            derived.method();
            //父类变量方法调用
            //通过子类对象访问父类与子类中不同名方法时，优先在子类中找，
            // 找到则访问，否则在父类中找，找到则访问，否则编译报错。
            //通过派生类对象访问父类与子类同名方法时，
            //如果父类和子类同名方法的参数列表不同(重载)，根据调用
            //方法适传递的参数选择合适的方法访问，如果没有则报错；
        }

        public static void main3(String[] args) {
            //super关键字：在子类方法中访问父类的成员。
            //1. 只能在非静态方法中使用
            //2. 在子类方法中，访问父类的成员变量和方法。
            //1.super.变量 2.super.方法
            // 1.this.变量 2.this.方法 3.this(构造方法) (当子类中不存在变量时 调用父类变量)
    }

        public static void main4(String[] args) {
            //子类构造方法
            //子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父子父子
            //肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整
            //，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整 。
            //注意
            //1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构
            //造方法
            //2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的
            //父类构造方法调用，否则编译失败。
            //3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。
            //4. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现
            Dog dog = new Dog("小灰",1,"灰色");
            dog.eat();
            dog.bark();
            Cat cat = new Cat("喵喵",1);
            cat.eat();
            cat.bark();
            //super 和 this 异同
            //1. 都是Java中的关键字
            //2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
            //3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在
            //不同
            //1. this是当前对象的引用，当前对象即调用实例方法的对象，
            // super相当于是子类对象中从父类继承下来部分成员的引用
            //2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
            //3. 在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造方法中出现
            //4. 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有
        }

        public static void main5(String[] args) {
            //初始化顺序（静态化只初始一次）
            //父类静态化
            //子类静态化
            //父类实例化
            //父类构造方法
            //子类实例化
            //子类构造方法
            Dog dog = new Dog("小灰",1,"灰色");
            System.out.println("-------------------");
            Dog dog1 = new Dog("小白",2,"白色");
            //通过分析执行结果，得出以下结论：
            //1、父类静态代码块优先于子类静态代码块执行，且是最早执行
            //2、父类实例代码块和父类构造方法紧接着执行
            //3、子类的实例代码块和子类构造方法紧接着再执行
            //4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行
        }

        public static void main6(String[] args) {
            //protected关键字
            //我们希望类要尽量做到 "封装", 即隐藏内部实现细节, 只暴露出 必要 的信息给类的调用者.
            //因此我们在使用的时候应该尽可能的使用 比较严格 的访问权限. 例如如果一个方法能用 private, 就尽量不要
            //用 public.
            //另外, 还有一种 简单粗暴 的做法: 将所有的字段设为 private, 将所有的方法设为 public. 不过这种方式属于是
            //对访问权限的滥用, 还是更希望同学们能写代码的时候认真思考, 该类提供的字段方法到底给 "谁" 使用(是类内
            //部自己用, 还是类的调用者使用, 还是子类使用
        }

        public static void main7(String[] args) {
            //继承方式
            //单继承、多层继承、不同类继承一个类 不支持多继承
            //一般我们不希望出现超过三层的继承关系
        }

        public static void main8(String[] args) {
            //final关键字：final关键可以用来修饰变量、成员方法以及类。
            //1. 修饰变量或字段，表示常量(即不能修改
            //2. 修饰类：表示此类不能被继承
            //3. 修饰方法：表示该方法不能被重写
        }

        public static void main9(String[] args) {
            //继承（is -a）与组合(has -a):将一个类的实例作为另外一个类的字段。
            //能用组合尽量用
            //组合。
        }

        public static void main(String[] args) {
            //多态：具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。
        }
}
